home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / wprot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-08  |  79.3 KB  |  2,468 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.  
  4.   
  5.    3.26.90      Harry Morris, morris@think.com
  6.    3.30.90  Harry Morris 
  7.    -    removed chunk code from WAISSearchAPDU,
  8.    -    added makeWAISQueryType1Query() and readWAISType1Query() which replace
  9.    makeWAISQueryTerms() and makeWAISQueryDocs().
  10.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  11.    - renamed makeWAISType1Query() to makeWAISTextQuery()
  12.    renamed readWAISType1Query() to readWAISTextQuery()
  13.    5.29.90  TS - fixed bug in makeWAISQueryDocs
  14.    added CSTFreeWAISFoo functions
  15. */
  16.  
  17. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  18.  
  19.  
  20. #ifndef lint
  21. static char *RCSid = "$Header: /usr/users/freewais/FreeWAIS-0.1/ir/wprot.c,v 1.1 1993/02/16 15:05:35 freewais Exp $";
  22. #endif
  23.  
  24. /* Change log:
  25.  * $Log: wprot.c,v $
  26.  * Revision 1.1  1993/02/16  15:05:35  freewais
  27.  * Initial revision
  28.  *
  29.  * Revision 1.8  92/04/02  14:20:58  jonathan
  30.  * Backed out last change.
  31.  * 
  32.  * Revision 1.7  92/04/02  09:49:49  jonathan
  33.  * Don't free the doc->type in freeDocObj: it's not a copy!
  34.  * 
  35.  * Revision 1.6  92/02/12  13:57:34  jonathan
  36.  * Added "$Log" so RCS will put the log message in the header
  37.  * 
  38.  * 
  39. */
  40.  
  41. #define _C_WAIS_protocol_
  42.  
  43. /*      This file implements the Z39.50 extensions required for WAIS 
  44. */
  45.  
  46. #include "wprot.h"
  47. #include "cutil.h"
  48. #include "panic.h"
  49. #include <string.h> /* for memmove */
  50.  
  51. #ifndef ANSI_LIKE
  52. #include "ustubs.h"
  53. #endif
  54.  
  55. /* very rough estimates of the size of an object */
  56. #define DefWAISInitResponseSize         (size_t)200
  57. #define DefWAISSearchSize                       (size_t)3000
  58. #define DefWAISSearchResponseSize       (size_t)6000
  59. #define DefWAISPresentSize                      (size_t)1000
  60. #define DefWAISPresentResponseSize      (size_t)6000
  61. #define DefWAISDocHeaderSize            (size_t)500
  62. #define DefWAISShortHeaderSize          (size_t)200
  63. #define DefWAISLongHeaderSize           (size_t)800
  64. #define DefWAISDocTextSize                      (size_t)6000
  65. #define DefWAISDocHeadlineSize          (size_t)500
  66. #define DefWAISDocCodeSize                      (size_t)500
  67.  
  68. #define RESERVE_SPACE_FOR_WAIS_HEADER(len)      \
  69.      if (*len > 0)                                                      \
  70.         *len -= header_len;
  71.  
  72. static char* writeUserInfoHeader _AP((data_tag tag,long infoSize,       
  73.                                       long estHeaderSize,char* buffer,
  74.                                       long* len));
  75.  
  76. static unsigned long userInfoTagSize _AP((data_tag tag,
  77.                                           unsigned long length));
  78.  
  79. /*----------------------------------------------------------------------*/
  80.  
  81. char*
  82. writeInitInfo(init,buffer,len)
  83. InitAPDU* init;
  84. char* buffer;
  85. long* len;
  86. {
  87.   char *userInfo, *buf;
  88.   /* The WAIS protocol doesn't use init info - does now! JG*/
  89.  
  90.   /* older servers barf on this.  Someday we can use it... 
  91.   userInfo = (char *)init->UserInformationField; */
  92.   userInfo = NULL;
  93.  
  94.   if(userInfo != NULL) {
  95.     buf = writeString(userInfo, DT_UserInformationField, buffer, len);
  96.     return(buf);
  97.   }
  98.   else return buffer;
  99. }
  100.  
  101. /*----------------------------------------------------------------------*/
  102.  
  103. static char* readUserInfoHeader _AP((data_tag* tag,unsigned long* num,
  104.                                      char* buffer));
  105.  
  106. char*
  107. readInitInfo(info,buffer)
  108. void** info;
  109. char* buffer;
  110. {
  111.   /* The WAIS protocol doesn't use init info */
  112.   readString((char **)info, buffer);
  113.   return buffer;
  114. }
  115.  
  116. /*----------------------------------------------------------------------*/
  117.  
  118. static unsigned long
  119. userInfoTagSize(tag,length)
  120. data_tag tag;
  121. unsigned long length;
  122. /* return the number of bytes required to write the user info tag and
  123.    length 
  124.  */
  125. {
  126.   unsigned long size;
  127.  
  128.   /* calculate bytes required to represent tag.  max tag is 16K */
  129.   size = writtenCompressedIntSize(tag);
  130.   size += writtenCompressedIntSize(length);
  131.       
  132.   return(size);
  133. }   
  134.  
  135. /*----------------------------------------------------------------------*/
  136.  
  137. static char*
  138. writeUserInfoHeader(tag,infoSize,estHeaderSize,buffer,len)
  139. data_tag tag;
  140. long infoSize;
  141. long estHeaderSize;
  142. char* buffer;
  143. long* len;
  144. /* write the tag and size, making sure the info fits.  return the true end
  145.    of the info (after adjustment) note that the argument infoSize includes
  146.    estHeaderSize.  Note that the argument len is the number of bytes remaining
  147.    in the buffer.  Since we write the tag and size at the begining of the
  148.    buffer (in space that we reserved) we don't want to pass len the calls which
  149.    do that writing. 
  150.  */
  151. {
  152.   long dummyLen = 100;          /* plenty of space for a tag and size */
  153.   char* buf = buffer;
  154.   long realSize = infoSize - estHeaderSize;
  155.   long realHeaderSize = userInfoTagSize(tag,realSize);
  156.  
  157.   if (buffer == NULL || *len == 0)
  158.     return(NULL);
  159.   
  160.   /* write the tag */
  161.   buf = writeTag(tag,buf,&dummyLen);
  162.   
  163.   /* see if the if the header size was correct. if not,
  164.      we have to shift the info to fit the real header size */
  165.   if (estHeaderSize != realHeaderSize)
  166.     {                           /* make sure there is enough space */
  167.       CHECK_FOR_SPACE_LEFT(realHeaderSize - estHeaderSize,len);
  168.       memmove(buffer + realHeaderSize,buffer + estHeaderSize,(size_t)(realSize));
  169.     }
  170.    
  171.   /* write the size */
  172.   writeCompressedInteger(realSize,buf,&dummyLen);
  173.   
  174.   /* return the true end of buffer */
  175.   return(buffer + realHeaderSize + realSize);
  176. }
  177.  
  178. /*----------------------------------------------------------------------*/
  179.  
  180. static char*
  181. readUserInfoHeader(tag,num,buffer)
  182. data_tag* tag;
  183. unsigned long* num;
  184. char* buffer;
  185. /* read the tag and size */
  186. {
  187.   char* buf = buffer;
  188.   buf = readTag(tag,buf);
  189.   buf = readCompressedInteger(num,buf);
  190.   return(buf); 
  191. }
  192.  
  193. /*----------------------------------------------------------------------*/
  194.  
  195. WAISInitResponse* 
  196. makeWAISInitResponse(chunkCode,
  197.                      chunkIDLen,
  198.                      chunkMarker,
  199.                      highlightMarker,
  200.                      deHighlightMarker,
  201.                      newLineChars)
  202. long chunkCode;
  203. long chunkIDLen;
  204. char* chunkMarker;
  205. char* highlightMarker;
  206. char* deHighlightMarker;
  207. char* newLineChars;
  208. /* create a WAIS init response object */
  209. {
  210.   WAISInitResponse* init = (WAISInitResponse*)s_malloc((size_t)sizeof(WAISInitResponse));
  211.  
  212.   init->ChunkCode = chunkCode;  /* note: none are copied! */
  213.   init->ChunkIDLength = chunkIDLen;
  214.   init->ChunkMarker = chunkMarker;
  215.   init->HighlightMarker = highlightMarker;
  216.   init->DeHighlightMarker = deHighlightMarker;
  217.   init->NewlineCharacters = newLineChars;
  218.   
  219.   return(init);
  220. }
  221.  
  222. /*----------------------------------------------------------------------*/
  223.  
  224. void 
  225. freeWAISInitResponse(init)
  226. WAISInitResponse* init;
  227. /* free an object made with makeWAISInitResponse */
  228. {
  229.   s_free(init->ChunkMarker);
  230.   s_free(init->HighlightMarker);
  231.   s_free(init->DeHighlightMarker);
  232.   s_free(init->NewlineCharacters);
  233.   s_free(init);
  234. }
  235.  
  236. /*----------------------------------------------------------------------*/
  237.  
  238. char*
  239. writeInitResponseInfo(init,buffer,len)
  240. InitResponseAPDU* init;
  241. char* buffer;
  242. long* len;
  243. /* write an init response object */
  244. {
  245.   unsigned long header_len = userInfoTagSize(DT_UserInformationLength,
  246.                                              DefWAISInitResponseSize);
  247.   char* buf = buffer + header_len;
  248.   WAISInitResponse* info = (WAISInitResponse*)init->UserInformationField;
  249.   unsigned long size;
  250.   
  251.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  252.     
  253.   buf = writeNum(info->ChunkCode,DT_ChunkCode,buf,len);
  254.   buf = writeNum(info->ChunkIDLength,DT_ChunkIDLength,buf,len);
  255.   buf = writeString(info->ChunkMarker,DT_ChunkMarker,buf,len);
  256.   buf = writeString(info->HighlightMarker,DT_HighlightMarker,buf,len);
  257.   buf = writeString(info->DeHighlightMarker,DT_DeHighlightMarker,buf,len);
  258.   buf = writeString(info->NewlineCharacters,DT_NewlineCharacters,buf,len);
  259.   
  260.   /* now write the header and size */
  261.   size = buf - buffer; 
  262.   buf = writeUserInfoHeader(DT_UserInformationLength,size,header_len,buffer,len);
  263.   
  264.   return(buf);
  265. }
  266.  
  267. /*----------------------------------------------------------------------*/
  268.  
  269. char*
  270. readInitResponseInfo(info,buffer)
  271. void** info;
  272. char* buffer;
  273. /* read an init response object */
  274. {
  275.   char* buf = buffer;
  276.   unsigned long size; 
  277.   unsigned long headerSize;
  278.   data_tag tag;
  279.   long chunkCode,chunkIDLen;
  280.   char* chunkMarker = NULL;
  281.   char* highlightMarker = NULL;
  282.   char* deHighlightMarker = NULL;
  283.   char* newLineChars = NULL;
  284.   
  285.   chunkCode = chunkIDLen = UNUSED;
  286.   
  287.   buf = readUserInfoHeader(&tag,&size,buf);
  288.   headerSize = buf - buffer;
  289.     
  290.   while (buf < (buffer + size + headerSize))
  291.     { data_tag tag = peekTag(buf);
  292.       switch (tag)
  293.         { case DT_ChunkCode:
  294.             buf = readNum(&chunkCode,buf);
  295.             break;
  296.           case DT_ChunkIDLength:
  297.             buf = readNum(&chunkIDLen,buf);
  298.             break;
  299.           case DT_ChunkMarker:
  300.             buf = readString(&chunkMarker,buf);
  301.             break;
  302.           case DT_HighlightMarker:
  303.             buf = readString(&highlightMarker,buf);
  304.             break;
  305.           case DT_DeHighlightMarker:
  306.             buf = readString(&deHighlightMarker,buf);
  307.             break;
  308.           case DT_NewlineCharacters:
  309.             buf = readString(&newLineChars,buf);
  310.             break;
  311.           default:
  312.             s_free(highlightMarker);
  313.             s_free(deHighlightMarker);
  314.             s_free(newLineChars);
  315.             REPORT_READ_ERROR(buf);
  316.             break;
  317.           }
  318.     }
  319.           
  320.   *info = (void *)makeWAISInitResponse(chunkCode,chunkIDLen,chunkMarker,
  321.                                highlightMarker,deHighlightMarker,
  322.                                newLineChars);
  323.   return(buf);
  324. }
  325.  
  326. /*----------------------------------------------------------------------*/
  327.  
  328. WAISSearch* 
  329. makeWAISSearch(seedWords,
  330.                docs,
  331.                textList,
  332.                dateFactor,
  333.                beginDateRange,
  334.                endDateRange,
  335.                maxDocsRetrieved)
  336. char* seedWords;
  337. DocObj** docs;
  338. char** textList;
  339. long dateFactor;
  340. char* beginDateRange;
  341. char* endDateRange;
  342. long maxDocsRetrieved;
  343.  
  344. /* create a type 3 query object */
  345. { 
  346.   WAISSearch* query = (WAISSearch*)s_malloc((size_t)sizeof(WAISSearch));
  347.  
  348.   query->SeedWords = seedWords; /* not copied! */
  349.   query->Docs = docs;           /* not copied! */
  350.   query->TextList = textList;   /* not copied! */
  351.   query->DateFactor = dateFactor;
  352.   query->BeginDateRange = beginDateRange;
  353.   query->EndDateRange = endDateRange;
  354.   query->MaxDocumentsRetrieved = maxDocsRetrieved;
  355.   
  356.   return(query);
  357. }
  358.  
  359. /*----------------------------------------------------------------------*/
  360.  
  361. void 
  362. freeWAISSearch(query)
  363. WAISSearch* query;
  364.  
  365. /* destroy an object made with makeWAISSearch() */
  366. {
  367.   void* ptr = NULL;
  368.   long i;
  369.   
  370.   s_free(query->SeedWords);
  371.   
  372.   if (query->Docs != NULL)
  373.     for (i = 0,ptr = (void *)query->Docs[i]; ptr != NULL; ptr = (void *)query->Docs[++i])
  374.       freeDocObj((DocObj*)ptr);
  375.   s_free(query->Docs);
  376.    
  377.   if (query->TextList != NULL)  /* XXX revisit when textlist is fully defined */
  378.     for (i = 0,ptr = (void *)query->TextList[i]; ptr != NULL; ptr = (void *)query->TextList[++i])
  379.       s_free(ptr);
  380.   s_free(query->TextList);
  381.  
  382.   s_free(query->BeginDateRange);
  383.   s_free(query->EndDateRange);
  384.   s_free(query);
  385. }
  386.  
  387. /*----------------------------------------------------------------------*/
  388.  
  389. DocObj* 
  390. makeDocObjUsingWholeDocument(docID,type)
  391. any* docID;
  392. char* type;
  393.  
  394. /* construct a document object using byte chunks - only for use by
  395.    servers */
  396. {
  397.   DocObj* doc = (DocObj*)s_malloc((size_t)sizeof(DocObj));
  398.   doc->DocumentID = docID;              /* not copied! */
  399.   doc->Type = type;             /* not copied! */
  400.   doc->ChunkCode = CT_document;
  401.   return(doc);
  402. }
  403.  
  404. /*----------------------------------------------------------------------*/
  405.  
  406. DocObj* 
  407. makeDocObjUsingLines(docID,type,start,end)
  408. any* docID;
  409. char* type;
  410. long start;
  411. long end;
  412.  
  413. /* construct a document object using line chunks - only for use by
  414.    servers */
  415. {
  416.   DocObj* doc = (DocObj*)s_malloc((size_t)sizeof(DocObj));
  417.   doc->ChunkCode = CT_line;
  418.   doc->DocumentID = docID;              /* not copied */
  419.   doc->Type = type;             /* not copied! */
  420.   doc->ChunkStart.Pos = start;
  421.   doc->ChunkEnd.Pos = end;
  422.   return(doc);
  423. }
  424.  
  425. /*----------------------------------------------------------------------*/
  426.  
  427.  
  428. DocObj* 
  429. makeDocObjUsingBytes(docID,type,start,end)
  430. any* docID;
  431. char* type;
  432. long start;
  433. long end;
  434.  
  435. /* construct a document object using byte chunks - only for use by
  436.    servers */
  437. {
  438.   DocObj* doc = (DocObj*)s_malloc((size_t)sizeof(DocObj));
  439.   doc->ChunkCode = CT_byte;
  440.   doc->DocumentID = docID;              /* not copied */
  441.   doc->Type = type;             /* not copied! */
  442.   doc->ChunkStart.Pos = start;
  443.   doc->ChunkEnd.Pos = end;
  444.   return(doc);
  445. }
  446.  
  447. /*----------------------------------------------------------------------*/
  448.  
  449. DocObj* 
  450. makeDocObjUsingParagraphs(docID,type,start,end)
  451. any* docID;
  452. char* type;
  453. any* start;
  454. any* end;
  455.  
  456. /* construct a document object using byte chunks - only for use by
  457.    servers */
  458. {
  459.   DocObj* doc = (DocObj*)s_malloc((size_t)sizeof(DocObj));
  460.   doc->ChunkCode = CT_paragraph;
  461.   doc->DocumentID = docID;              /* not copied */
  462.   doc->Type = type;
  463.   doc->ChunkStart.ID = start; 
  464.   doc->ChunkEnd.ID = end; 
  465.   return(doc);
  466. }
  467.  
  468. /*----------------------------------------------------------------------*/
  469.  
  470. void
  471. freeDocObj(doc)
  472. DocObj* doc;
  473.  
  474. /* free a docObj */
  475. {
  476.   freeAny(doc->DocumentID);
  477.   s_free(doc->Type);
  478.   if (doc->ChunkCode == CT_paragraph)
  479.     { freeAny(doc->ChunkStart.ID);
  480.       freeAny(doc->ChunkEnd.ID);
  481.     }
  482.   s_free(doc);
  483. }
  484.  
  485. /*----------------------------------------------------------------------*/
  486.  
  487. static char* writeDocObj _AP((DocObj* doc,char* buffer,long* len));
  488.  
  489. static char*
  490. writeDocObj(doc,buffer,len)
  491. DocObj* doc;
  492. char* buffer;
  493. long* len;
  494.  
  495. /* write as little as we can about the doc obj */
  496. {
  497.   char* buf = buffer;
  498.   
  499.   /* we alwasy have to write the id, but its tag depends on if its a chunk */
  500.   if (doc->ChunkCode == CT_document)
  501.     buf = writeAny(doc->DocumentID,DT_DocumentID,buf,len);
  502.   else
  503.     buf = writeAny(doc->DocumentID,DT_DocumentIDChunk,buf,len);
  504.   
  505.   if (doc->Type != NULL)
  506.     buf = writeString(doc->Type,DT_TYPE,buf,len);
  507.   
  508.   switch (doc->ChunkCode)
  509.     { case CT_document:
  510.         /* do nothing - there is no chunk data */
  511.         break;
  512.       case CT_byte:
  513.       case CT_line:
  514.         buf = writeNum(doc->ChunkCode,DT_ChunkCode,buf,len);
  515.         buf = writeNum(doc->ChunkStart.Pos,DT_ChunkStartID,buf,len);
  516.         buf = writeNum(doc->ChunkEnd.Pos,DT_ChunkEndID,buf,len);
  517.         break;
  518.       case CT_paragraph:
  519.         buf = writeNum(doc->ChunkCode,DT_ChunkCode,buf,len);
  520.         buf = writeAny(doc->ChunkStart.ID,DT_ChunkStartID,buf,len);
  521.         buf = writeAny(doc->ChunkEnd.ID,DT_ChunkEndID,buf,len);
  522.         break;
  523.       default:
  524.         panic("Implementation error: unknown chuck type %ld",
  525.               doc->ChunkCode);
  526.         break;
  527.       }
  528.    
  529.   return(buf);
  530. }
  531.  
  532. /*----------------------------------------------------------------------*/
  533.  
  534. static char* readDocObj _AP((DocObj** doc,char* buffer));
  535.  
  536. static char*
  537. readDocObj(doc,buffer)
  538. DocObj** doc;
  539. char* buffer;
  540.  
  541. /* read whatever we have about the new document */
  542. {
  543.   char* buf = buffer;
  544.   data_tag tag;
  545.   
  546.   *doc = (DocObj*)s_malloc((size_t)sizeof(DocObj));
  547.   
  548.   tag = peekTag(buf);
  549.   buf = readAny(&((*doc)->DocumentID),buf);
  550.   
  551.   if (tag == DT_DocumentID)
  552.     { (*doc)->ChunkCode = CT_document;
  553.       tag = peekTag(buf);
  554.       if (tag == DT_TYPE)       /* XXX depends on DT_TYPE != what comes next */
  555.         buf = readString(&((*doc)->Type),buf);
  556.       /* ChunkStart and ChunkEnd are undefined */
  557.     }
  558.   else if (tag == DT_DocumentIDChunk)
  559.     { Boolean readParagraphs = false; /* for cleanup */
  560.       tag = peekTag(buf);
  561.       if (tag == DT_TYPE)       /* XXX depends on DT_TYPE != CT_FOO */
  562.         buf = readString(&((*doc)->Type),buf);
  563.       buf = readNum(&((*doc)->ChunkCode),buf);
  564.       switch ((*doc)->ChunkCode)
  565.         { case CT_byte:
  566.           case CT_line:
  567.             buf = readNum(&((*doc)->ChunkStart.Pos),buf);
  568.             buf = readNum(&((*doc)->ChunkEnd.Pos),buf);
  569.             break;
  570.           case CT_paragraph:
  571.             readParagraphs = true;
  572.             buf = readAny(&((*doc)->ChunkStart.ID),buf);
  573.             buf = readAny(&((*doc)->ChunkEnd.ID),buf);
  574.             break;
  575.           default:
  576.             freeAny((*doc)->DocumentID);
  577.             if (readParagraphs)
  578.               { freeAny((*doc)->ChunkStart.ID);
  579.                 freeAny((*doc)->ChunkEnd.ID);
  580.               }
  581.             s_free(doc);
  582.             REPORT_READ_ERROR(buf);
  583.             break;
  584.           }
  585.     }
  586.   else
  587.     { freeAny((*doc)->DocumentID);
  588.       s_free(*doc);
  589.       REPORT_READ_ERROR(buf);
  590.     }
  591.   return(buf);  
  592. }
  593.  
  594. /*----------------------------------------------------------------------*/
  595.  
  596. char* 
  597. writeSearchInfo(query,buffer,len)
  598. SearchAPDU* query;
  599. char* buffer;
  600. long* len;
  601.  
  602. /* write out a WAIS query (type 1 or 3) */
  603. {
  604.   if (strcmp(query->QueryType,QT_TextRetrievalQuery) == 0)
  605.     { return(writeAny((any*)query->Query,DT_Query,buffer,len));
  606.     }
  607.   else
  608.     { unsigned long header_len = userInfoTagSize(DT_UserInformationLength,
  609.                                                  DefWAISSearchSize); 
  610.       char* buf = buffer + header_len;
  611.       WAISSearch* info = (WAISSearch*)query->Query;
  612.       unsigned long size;
  613.       long i;
  614.   
  615.       RESERVE_SPACE_FOR_WAIS_HEADER(len);
  616.        
  617.       buf = writeString(info->SeedWords,DT_SeedWords,buf,len);
  618.  
  619.       if (info->Docs != NULL)
  620.       { for (i = 0; info->Docs[i] != NULL; i++)
  621.           { buf = writeDocObj(info->Docs[i],buf,len);
  622.           }
  623.         }
  624.    
  625.       /* XXX text list */
  626.  
  627.       buf = writeNum(info->DateFactor,DT_DateFactor,buf,len);
  628.       buf = writeString(info->BeginDateRange,DT_BeginDateRange,buf,len);
  629.       buf = writeString(info->EndDateRange,DT_EndDateRange,buf,len);
  630.       buf = writeNum(info->MaxDocumentsRetrieved,DT_MaxDocumentsRetrieved,buf,len);
  631.   
  632.       /* now write the header and size */
  633.       size = buf - buffer; 
  634.       buf = writeUserInfoHeader(DT_UserInformationLength,size,header_len,buffer,len);
  635.    
  636.       return(buf);
  637.     }
  638. }
  639.  
  640. /*----------------------------------------------------------------------*/
  641.  
  642. char* 
  643. readSearchInfo(info,buffer)
  644. void** info;
  645. char* buffer;
  646.  
  647. /* read a WAIS query (type 1 or 3) */
  648. {
  649.   data_tag type = peekTag(buffer);
  650.   if (type == DT_Query)         /* this is a type 1 query */
  651.     { char* buf = buffer;
  652.       any* query = NULL;
  653.       buf = readAny(&query,buf);
  654.       *info = (void *)query;
  655.       return(buf);
  656.     }
  657.   else                          /* a type 3 query */
  658.     { char* buf = buffer;
  659.       unsigned long size; 
  660.       unsigned long headerSize;
  661.       data_tag tag;
  662.       char* seedWords = NULL;
  663.       char* beginDateRange = NULL;
  664.       char* endDateRange = NULL;
  665.       long dateFactor,maxDocsRetrieved;
  666.       char** textList = NULL; 
  667.       DocObj** docIDs = NULL;
  668.       DocObj* doc = NULL;
  669.       long docs = 0;
  670.       long i;
  671.       void* ptr = NULL;
  672.  
  673.       dateFactor = maxDocsRetrieved = UNUSED;
  674.   
  675.       buf = readUserInfoHeader(&tag,&size,buf);
  676.       headerSize = buf - buffer;
  677.   
  678.       while (buf < (buffer + size + headerSize))
  679.         { data_tag tag = peekTag(buf);
  680.           switch (tag)
  681.             { case DT_SeedWords:
  682.                 buf = readString(&seedWords,buf);
  683.                 break;
  684.               case DT_DocumentID:
  685.               case DT_DocumentIDChunk:
  686.                 if (docIDs == NULL) /* create a new doc list */
  687.                   { docIDs = (DocObj**)s_malloc((size_t)sizeof(DocObj*) * 2);
  688.                   }
  689.                 else            /* grow the doc list */
  690.                   { docIDs = (DocObj**)s_realloc((char*)docIDs,(size_t)(sizeof(DocObj*) * (docs + 2)));
  691.                   }
  692.                 buf = readDocObj(&doc,buf);
  693.                 if (buf == NULL) 
  694.                   { s_free(seedWords);
  695.                     s_free(beginDateRange);
  696.                     s_free(endDateRange);
  697.                     if (docIDs != NULL)
  698.                       for (i = 0,ptr = (void *)docIDs[i]; ptr != NULL; ptr = (void *)docIDs[++i])
  699.                         freeDocObj((DocObj*)ptr);
  700.                     s_free(docIDs);
  701.                     /* XXX should also free textlist when it is fully defined */
  702.                   }
  703.                 RETURN_ON_NULL(buf);
  704.                 docIDs[docs++] = doc; /* put it in the list */
  705.                 docIDs[docs] = NULL;
  706.                 break;
  707.               case DT_TextList:
  708.                 /* XXX */
  709.                 break;
  710.               case DT_DateFactor:
  711.                 buf = readNum(&dateFactor,buf);
  712.                 break;
  713.               case DT_BeginDateRange:
  714.                 buf = readString(&beginDateRange,buf);
  715.                 break;
  716.               case DT_EndDateRange:
  717.                 buf = readString(&endDateRange,buf);
  718.                 break;
  719.               case DT_MaxDocumentsRetrieved:
  720.                 buf = readNum(&maxDocsRetrieved,buf);
  721.                 break;
  722.               default:
  723.                 s_free(seedWords);
  724.                 s_free(beginDateRange);
  725.                 s_free(endDateRange);
  726.                 if (docIDs != NULL)
  727.                   for (i = 0,ptr = (void *)docIDs[i]; ptr != NULL; ptr = (void *)docIDs[++i])
  728.                     freeDocObj((DocObj*)ptr);
  729.                 s_free(docIDs);
  730.                 /* XXX should also free textlist when it is fully defined */
  731.                 REPORT_READ_ERROR(buf);
  732.                 break;
  733.               }
  734.         }
  735.           
  736.       *info = (void *)makeWAISSearch(seedWords,docIDs,textList,
  737.                                      dateFactor,beginDateRange,endDateRange,
  738.                                      maxDocsRetrieved);
  739.       return(buf);
  740.     }
  741. }
  742.  
  743. /*----------------------------------------------------------------------*/
  744.  
  745. WAISDocumentHeader*
  746. makeWAISDocumentHeader(docID,
  747.                        versionNumber,
  748.                        score,
  749.                        bestMatch,
  750.                        docLen,
  751.                        lines,
  752.                        types,
  753.                        source,
  754.                        date,
  755.                        headline,
  756.                        originCity)
  757. any* docID;
  758. long versionNumber;
  759. long score;
  760. long bestMatch;
  761. long docLen;
  762. long lines;
  763. char** types;
  764. char* source;
  765. char* date;
  766. char* headline;
  767. char* originCity;
  768.  
  769. /* construct a standard document header, note that no fields are copied!
  770.    if the application needs to save these fields, it should copy them,
  771.    or set the field in this object to NULL before freeing it.
  772.  */
  773. {
  774.   WAISDocumentHeader* header = 
  775.     (WAISDocumentHeader*)s_malloc((size_t)sizeof(WAISDocumentHeader));
  776.  
  777.   header->DocumentID = docID;
  778.   header->VersionNumber = versionNumber;
  779.   header->Score = score;
  780.   header->BestMatch = bestMatch;
  781.   header->DocumentLength = docLen;
  782.   header->Lines = lines;
  783.   header->Types = types;
  784.   header->Source = source;
  785.   header->Date = date;
  786.   header->Headline = headline;
  787.   header->OriginCity = originCity;
  788.   
  789.   return(header);
  790. }
  791.  
  792. /*----------------------------------------------------------------------*/
  793.  
  794. void
  795. freeWAISDocumentHeader(header)
  796. WAISDocumentHeader* header;
  797.  
  798. {
  799.   freeAny(header->DocumentID);
  800.   doList((void**)header->Types,fs_free); /* can't use the macro here ! */
  801.   s_free(header->Types);
  802.   s_free(header->Source);
  803.   s_free(header->Date);
  804.   s_free(header->Headline);
  805.   s_free(header->OriginCity);
  806.   s_free(header);
  807. }
  808.  
  809. /*----------------------------------------------------------------------*/
  810.  
  811. char*
  812. writeWAISDocumentHeader(header,buffer,len)
  813. WAISDocumentHeader* header;
  814. char* buffer;
  815. long* len;
  816. {
  817.   unsigned long header_len = userInfoTagSize(DT_DocumentHeaderGroup ,
  818.                                              DefWAISDocHeaderSize);
  819.   char* buf = buffer + header_len;
  820.   unsigned long size;
  821.   
  822.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  823.    
  824.   buf = writeAny(header->DocumentID,DT_DocumentID,buf,len);
  825.   buf = writeNum(header->VersionNumber,DT_VersionNumber,buf,len);
  826.   buf = writeNum(header->Score,DT_Score,buf,len);
  827.   buf = writeNum(header->BestMatch,DT_BestMatch,buf,len);
  828.   buf = writeNum(header->DocumentLength,DT_DocumentLength,buf,len);
  829.   buf = writeNum(header->Lines,DT_Lines,buf,len);
  830.   if (header->Types != NULL)
  831.     { long size;
  832.       char* ptr = NULL;
  833.       long i;
  834.       buf = writeTag(DT_TYPE_BLOCK,buf,len);
  835.       for (i = 0,size = 0,ptr = header->Types[i]; ptr != NULL; ptr = header->Types[++i])
  836.         { long typeSize = strlen(ptr);
  837.           size += writtenTagSize(DT_TYPE);
  838.           size += writtenCompressedIntSize(typeSize);
  839.           size += typeSize; 
  840.         }
  841.       buf = writeCompressedInteger((unsigned long)size,buf,len);
  842.       for (i = 0,ptr = header->Types[i]; ptr != NULL; ptr = header->Types[++i])
  843.         buf = writeString(ptr,DT_TYPE,buf,len);
  844.     }
  845.   buf = writeString(header->Source,DT_Source,buf,len);
  846.   buf = writeString(header->Date,DT_Date,buf,len);
  847.   buf = writeString(header->Headline,DT_Headline,buf,len);
  848.   buf = writeString(header->OriginCity,DT_OriginCity,buf,len);
  849.   
  850.   /* now write the header and size */
  851.   size = buf - buffer; 
  852.   buf = writeUserInfoHeader(DT_DocumentHeaderGroup,size,header_len,buffer,len);
  853.  
  854.   return(buf);
  855. }
  856.  
  857. /*----------------------------------------------------------------------*/
  858.  
  859. char*
  860. readWAISDocumentHeader(header,buffer)
  861. WAISDocumentHeader** header;
  862. char* buffer;
  863. {
  864.   char* buf = buffer;
  865.   unsigned long size; 
  866.   unsigned long headerSize;
  867.   data_tag tag;
  868.   any* docID = NULL;
  869.   long versionNumber,score,bestMatch,docLength,lines;
  870.   char** types = NULL;
  871.   char *source = NULL;
  872.   char *date = NULL;
  873.   char *headline = NULL;
  874.   char *originCity = NULL;
  875.   
  876.   versionNumber = score = bestMatch = docLength = lines = UNUSED;
  877.   
  878.   buf = readUserInfoHeader(&tag,&size,buf);
  879.   headerSize = buf - buffer;
  880.     
  881.   while (buf < (buffer + size + headerSize))
  882.     { data_tag tag = peekTag(buf);
  883.       switch (tag)
  884.         { case DT_DocumentID:
  885.             buf = readAny(&docID,buf);
  886.             break;
  887.           case DT_VersionNumber:
  888.             buf = readNum(&versionNumber,buf);
  889.             break;
  890.           case DT_Score:
  891.             buf = readNum(&score,buf);
  892.             break;
  893.           case DT_BestMatch:
  894.             buf = readNum(&bestMatch,buf);
  895.             break;
  896.           case DT_DocumentLength:
  897.             buf = readNum(&docLength,buf);
  898.             break;
  899.           case DT_Lines:
  900.             buf = readNum(&lines,buf);
  901.             break;
  902.           case DT_TYPE_BLOCK:
  903. #ifdef WIN32
  904.             { unsigned long size = 0;
  905. #else
  906.             { unsigned long size = -1;
  907. #endif
  908.               long numTypes = 0;
  909.               buf = readTag(&tag,buf);
  910.               buf = readCompressedInteger(&size,buf);
  911.               while (size > 0)
  912.                 { char* type = NULL;
  913.                   char* originalBuf = buf;
  914.                   buf = readString(&type,buf);
  915.                   types = (char**)s_realloc(types,(size_t)(sizeof(char*) * (numTypes + 2)));
  916.                   types[numTypes++] = type;
  917.                   types[numTypes] = NULL;
  918.                   size -= (buf - originalBuf);
  919.                 }
  920.             }
  921.           case DT_Source:
  922.             buf = readString(&source,buf);
  923.             break;
  924.           case DT_Date:
  925.             buf = readString(&date,buf);
  926.             break;
  927.           case DT_Headline:
  928.             buf = readString(&headline,buf);
  929.             break;
  930.           case DT_OriginCity:
  931.             buf = readString(&originCity,buf);
  932.             break;
  933.           default:
  934.             freeAny(docID);
  935.             s_free(source);
  936.             s_free(date);
  937.             s_free(headline);
  938.             s_free(originCity);
  939.             REPORT_READ_ERROR(buf);
  940.             break;
  941.           }
  942.     }
  943.           
  944.   *header = makeWAISDocumentHeader(docID,versionNumber,score,bestMatch,
  945.                                    docLength,lines,types,source,date,headline,
  946.                                    originCity);
  947.   return(buf);
  948. }
  949.  
  950. /*----------------------------------------------------------------------*/
  951.  
  952. WAISDocumentShortHeader*
  953. makeWAISDocumentShortHeader(docID,
  954.                             versionNumber,
  955.                             score,
  956.                             bestMatch,
  957.                             docLen,
  958.                             lines)
  959. any* docID;
  960. long versionNumber;
  961. long score;
  962. long bestMatch;
  963. long docLen;
  964. long lines;
  965. /* construct a short document header, note that no fields are copied!
  966.    if the application needs to save these fields, it should copy them,
  967.    or set the field in this object to NULL before freeing it.
  968.  */
  969. {
  970.   WAISDocumentShortHeader* header = 
  971.     (WAISDocumentShortHeader*)s_malloc((size_t)sizeof(WAISDocumentShortHeader));
  972.  
  973.   header->DocumentID = docID;
  974.   header->VersionNumber = versionNumber;
  975.   header->Score = score;
  976.   header->BestMatch = bestMatch;
  977.   header->DocumentLength = docLen;
  978.   header->Lines = lines;
  979.   
  980.   return(header);
  981. }
  982.  
  983. /*----------------------------------------------------------------------*/
  984.  
  985. void
  986. freeWAISDocumentShortHeader(header)
  987. WAISDocumentShortHeader* header;
  988. {
  989.   freeAny(header->DocumentID);
  990.   s_free(header);
  991. }
  992.  
  993. /*----------------------------------------------------------------------*/
  994.  
  995. char*
  996. writeWAISDocumentShortHeader(header,buffer,len)
  997. WAISDocumentShortHeader* header;
  998. char* buffer;
  999. long* len;
  1000. {
  1001.   unsigned long header_len = userInfoTagSize(DT_DocumentShortHeaderGroup ,
  1002.                                              DefWAISShortHeaderSize);
  1003.   char* buf = buffer + header_len;
  1004.   unsigned long size;
  1005.   
  1006.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  1007.    
  1008.   buf = writeAny(header->DocumentID,DT_DocumentID,buf,len);
  1009.   buf = writeNum(header->VersionNumber,DT_VersionNumber,buf,len);
  1010.   buf = writeNum(header->Score,DT_Score,buf,len);
  1011.   buf = writeNum(header->BestMatch,DT_BestMatch,buf,len);
  1012.   buf = writeNum(header->DocumentLength,DT_DocumentLength,buf,len);
  1013.   buf = writeNum(header->Lines,DT_Lines,buf,len);
  1014.   
  1015.   /* now write the header and size */
  1016.   size = buf - buffer; 
  1017.   buf = writeUserInfoHeader(DT_DocumentShortHeaderGroup,size,header_len,buffer,len);
  1018.  
  1019.   return(buf);
  1020. }
  1021.  
  1022. /*----------------------------------------------------------------------*/
  1023.  
  1024. char*
  1025. readWAISDocumentShortHeader(header,buffer)
  1026. WAISDocumentShortHeader** header;
  1027. char* buffer;
  1028. {
  1029.   char* buf = buffer;
  1030.   unsigned long size; 
  1031.   unsigned long headerSize;
  1032.   data_tag tag;
  1033.   any* docID = NULL;
  1034.   long versionNumber,score,bestMatch,docLength,lines;
  1035.   
  1036.   versionNumber = score = bestMatch = docLength = lines = UNUSED;
  1037.   
  1038.   buf = readUserInfoHeader(&tag,&size,buf);
  1039.   headerSize = buf - buffer;
  1040.     
  1041.   while (buf < (buffer + size + headerSize))
  1042.     { data_tag tag = peekTag(buf);
  1043.       switch (tag)
  1044.         { case DT_DocumentID:
  1045.             buf = readAny(&docID,buf);
  1046.             break;
  1047.           case DT_VersionNumber:
  1048.             buf = readNum(&versionNumber,buf);
  1049.             break;
  1050.           case DT_Score:
  1051.             buf = readNum(&score,buf);
  1052.             break;
  1053.           case DT_BestMatch:
  1054.             buf = readNum(&bestMatch,buf);
  1055.             break;
  1056.           case DT_DocumentLength:
  1057.             buf = readNum(&docLength,buf);
  1058.             break;
  1059.           case DT_Lines:
  1060.             buf = readNum(&lines,buf);
  1061.             break;
  1062.           default:
  1063.             freeAny(docID);
  1064.             REPORT_READ_ERROR(buf);
  1065.             break;
  1066.           }
  1067.     }
  1068.           
  1069.   *header = makeWAISDocumentShortHeader(docID,versionNumber,score,bestMatch,
  1070.                                         docLength,lines);
  1071.   return(buf);
  1072. }
  1073.  
  1074. /*----------------------------------------------------------------------*/
  1075.  
  1076. WAISDocumentLongHeader*
  1077. makeWAISDocumentLongHeader(docID,
  1078.                            versionNumber,
  1079.                            score,
  1080.                            bestMatch,
  1081.                            docLen,
  1082.                            lines,
  1083.                            types,
  1084.                            source,
  1085.                            date,
  1086.                            headline,
  1087.                            originCity,
  1088.                            stockCodes,
  1089.                            companyCodes,
  1090.                            industryCodes)
  1091. any* docID;
  1092. long versionNumber;
  1093. long score;
  1094. long bestMatch;
  1095. long docLen;
  1096. long lines;
  1097. char** types;
  1098. char* source;
  1099. char* date;
  1100. char* headline;
  1101. char* originCity;
  1102. char* stockCodes;
  1103. char* companyCodes;
  1104. char* industryCodes;
  1105. /* construct a long document header, note that no fields are copied!
  1106.    if the application needs to save these fields, it should copy them,
  1107.    or set the field in this object to NULL before freeing it.
  1108.  */
  1109. {
  1110.   WAISDocumentLongHeader* header = 
  1111.     (WAISDocumentLongHeader*)s_malloc((size_t)sizeof(WAISDocumentLongHeader));
  1112.  
  1113.   header->DocumentID = docID;
  1114.   header->VersionNumber = versionNumber;
  1115.   header->Score = score;
  1116.   header->BestMatch = bestMatch;
  1117.   header->DocumentLength = docLen;
  1118.   header->Lines = lines;
  1119.   header->Types = types;
  1120.   header->Source = source;
  1121.   header->Date = date;
  1122.   header->Headline = headline;
  1123.   header->OriginCity = originCity;
  1124.   header->StockCodes = stockCodes;
  1125.   header->CompanyCodes = companyCodes;
  1126.   header->IndustryCodes = industryCodes;
  1127.   
  1128.   return(header);
  1129. }
  1130.  
  1131. /*----------------------------------------------------------------------*/
  1132.  
  1133. void
  1134. freeWAISDocumentLongHeader(header)
  1135. WAISDocumentLongHeader* header;
  1136. {
  1137.   freeAny(header->DocumentID);
  1138.   doList((void**)header->Types,fs_free); /* can't use the macro here! */
  1139.   s_free(header->Source);
  1140.   s_free(header->Date);
  1141.   s_free(header->Headline);
  1142.   s_free(header->OriginCity);
  1143.   s_free(header->StockCodes);
  1144.   s_free(header->CompanyCodes);
  1145.   s_free(header->IndustryCodes);
  1146.   s_free(header);
  1147. }
  1148.  
  1149. /*----------------------------------------------------------------------*/
  1150.  
  1151. char*
  1152. writeWAISDocumentLongHeader(header,buffer,len)
  1153. WAISDocumentLongHeader* header;
  1154. char* buffer;
  1155. long* len;
  1156. {
  1157.   unsigned long header_len = userInfoTagSize(DT_DocumentLongHeaderGroup ,
  1158.                                              DefWAISLongHeaderSize);
  1159.   char* buf = buffer + header_len;
  1160.   unsigned long size;
  1161.   
  1162.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  1163.    
  1164.   buf = writeAny(header->DocumentID,DT_DocumentID,buf,len);
  1165.   buf = writeNum(header->VersionNumber,DT_VersionNumber,buf,len);
  1166.   buf = writeNum(header->Score,DT_Score,buf,len);
  1167.   buf = writeNum(header->BestMatch,DT_BestMatch,buf,len);
  1168.   buf = writeNum(header->DocumentLength,DT_DocumentLength,buf,len);
  1169.   buf = writeNum(header->Lines,DT_Lines,buf,len);
  1170.   if (header->Types != NULL)
  1171.     { long size;
  1172.       char* ptr = NULL;
  1173.       long i;
  1174.       buf = writeTag(DT_TYPE_BLOCK,buf,len);
  1175.       for (i = 0,size = 0,ptr = header->Types[i]; ptr != NULL; ptr = header->Types[++i])
  1176.         { long typeSize = strlen(ptr);
  1177.           size += writtenTagSize(DT_TYPE);
  1178.           size += writtenCompressedIntSize(typeSize);
  1179.           size += typeSize; 
  1180.         }
  1181.       buf = writeCompressedInteger((unsigned long)size,buf,len);
  1182.       for (i = 0,ptr = header->Types[i]; ptr != NULL; ptr = header->Types[++i])
  1183.         buf = writeString(ptr,DT_TYPE,buf,len);
  1184.     }
  1185.   buf = writeString(header->Source,DT_Source,buf,len);
  1186.   buf = writeString(header->Date,DT_Date,buf,len);
  1187.   buf = writeString(header->Headline,DT_Headline,buf,len);
  1188.   buf = writeString(header->OriginCity,DT_OriginCity,buf,len);
  1189.   buf = writeString(header->StockCodes,DT_StockCodes,buf,len);
  1190.   buf = writeString(header->CompanyCodes,DT_CompanyCodes,buf,len);
  1191.   buf = writeString(header->IndustryCodes,DT_IndustryCodes,buf,len);
  1192.   
  1193.   /* now write the header and size */
  1194.   size = buf - buffer; 
  1195.   buf = writeUserInfoHeader(DT_DocumentLongHeaderGroup,size,header_len,buffer,len);
  1196.  
  1197.   return(buf);
  1198. }
  1199.  
  1200. /*----------------------------------------------------------------------*/
  1201.  
  1202. char*
  1203. readWAISDocumentLongHeader(header,buffer)
  1204. WAISDocumentLongHeader** header;
  1205. char* buffer;
  1206. {
  1207.   char* buf = buffer;
  1208.   unsigned long size; 
  1209.   unsigned long headerSize;
  1210.   data_tag tag;
  1211.   any* docID;
  1212.   long versionNumber,score,bestMatch,docLength,lines;
  1213.   char **types;
  1214.   char *source,*date,*headline,*originCity,*stockCodes,*companyCodes,*industryCodes;
  1215.   
  1216.   docID = NULL;
  1217.   versionNumber = score = bestMatch = docLength = lines = UNUSED;
  1218.   types = NULL;
  1219.   source = date = headline = originCity = stockCodes = companyCodes = industryCodes = NULL;
  1220.   
  1221.   buf = readUserInfoHeader(&tag,&size,buf);
  1222.   headerSize = buf - buffer;
  1223.     
  1224.   while (buf < (buffer + size + headerSize))
  1225.     { data_tag tag = peekTag(buf);
  1226.       switch (tag)
  1227.         { case DT_DocumentID:
  1228.             buf = readAny(&docID,buf);
  1229.             break;
  1230.           case DT_VersionNumber:
  1231.             buf = readNum(&versionNumber,buf);
  1232.             break;
  1233.           case DT_Score:
  1234.             buf = readNum(&score,buf);
  1235.             break;
  1236.           case DT_BestMatch:
  1237.             buf = readNum(&bestMatch,buf);
  1238.             break;
  1239.           case DT_DocumentLength:
  1240.             buf = readNum(&docLength,buf);
  1241.             break;
  1242.           case DT_Lines:
  1243.             buf = readNum(&lines,buf);
  1244.             break;
  1245.           case DT_TYPE_BLOCK:
  1246. #ifdef WIN32
  1247.             { unsigned long size = 0;
  1248. #else
  1249.             { unsigned long size = -1;
  1250. #endif
  1251.               long numTypes = 0;
  1252.               buf = readTag(&tag,buf);
  1253.               readCompressedInteger(&size,buf);
  1254.               while (size > 0)
  1255.                 { char* type = NULL;
  1256.                   char* originalBuf = buf;
  1257.                   buf = readString(&type,buf);
  1258.                   types = (char**)s_realloc(types,(size_t)(sizeof(char*) * (numTypes + 2)));
  1259.                   types[numTypes++] = type;
  1260.                   types[numTypes] = NULL;
  1261.                   size -= (buf - originalBuf);
  1262.                 }
  1263.             }
  1264.           case DT_Source:
  1265.             buf = readString(&source,buf);
  1266.             break;
  1267.           case DT_Date:
  1268.             buf = readString(&date,buf);
  1269.             break;
  1270.           case DT_Headline:
  1271.             buf = readString(&headline,buf);
  1272.             break;
  1273.           case DT_OriginCity:
  1274.             buf = readString(&originCity,buf);
  1275.             break;
  1276.           case DT_StockCodes:
  1277.             buf = readString(&stockCodes,buf);
  1278.             break;
  1279.           case DT_CompanyCodes:
  1280.             buf = readString(&companyCodes,buf);
  1281.             break;
  1282.           case DT_IndustryCodes:
  1283.             buf = readString(&industryCodes,buf);
  1284.             break;
  1285.           default:
  1286.             freeAny(docID);
  1287.             s_free(source);
  1288.             s_free(date);
  1289.             s_free(headline);
  1290.             s_free(originCity);
  1291.             s_free(stockCodes);
  1292.             s_free(companyCodes);
  1293.             s_free(industryCodes);
  1294.             REPORT_READ_ERROR(buf);
  1295.             break;
  1296.           }
  1297.     }
  1298.           
  1299.   *header = makeWAISDocumentLongHeader(docID,versionNumber,score,bestMatch,
  1300.                                        docLength,lines,types,source,date,headline,
  1301.                                        originCity,stockCodes,companyCodes,
  1302.                                        industryCodes);
  1303.   return(buf);
  1304. }
  1305.  
  1306. /*----------------------------------------------------------------------*/
  1307.  
  1308. WAISSearchResponse*
  1309. makeWAISSearchResponse(seedWordsUsed,
  1310.                        docHeaders,
  1311.                        shortHeaders,
  1312.                        longHeaders,
  1313.                        text,
  1314.                        headlines,
  1315.                        codes,
  1316.                        diagnostics)
  1317. char* seedWordsUsed;
  1318. WAISDocumentHeader** docHeaders;
  1319. WAISDocumentShortHeader** shortHeaders;
  1320. WAISDocumentLongHeader** longHeaders;
  1321. WAISDocumentText** text;
  1322. WAISDocumentHeadlines** headlines;
  1323. WAISDocumentCodes** codes;
  1324. diagnosticRecord** diagnostics;
  1325. {
  1326.   WAISSearchResponse* response = (WAISSearchResponse*)s_malloc((size_t)sizeof(WAISSearchResponse));
  1327.   
  1328.   response->SeedWordsUsed = seedWordsUsed;
  1329.   response->DocHeaders = docHeaders;
  1330.   response->ShortHeaders = shortHeaders;
  1331.   response->LongHeaders = longHeaders;
  1332.   response->Text = text;
  1333.   response->Headlines = headlines;
  1334.   response->Codes = codes;
  1335.   response->Diagnostics = diagnostics;
  1336.   
  1337.   return(response);
  1338. }
  1339.  
  1340. /*----------------------------------------------------------------------*/
  1341.  
  1342. void
  1343. freeWAISSearchResponse(response)
  1344. WAISSearchResponse* response;
  1345. {
  1346.   void* ptr = NULL;
  1347.   long i;
  1348.  
  1349.   s_free(response->SeedWordsUsed);
  1350.  
  1351.   if (response->DocHeaders != NULL)
  1352.     for (i = 0,ptr = (void *)response->DocHeaders[i]; ptr != NULL; ptr = (void *)response->DocHeaders[++i])
  1353.       freeWAISDocumentHeader((WAISDocumentHeader*)ptr);
  1354.   s_free(response->DocHeaders);
  1355.    
  1356.   if (response->ShortHeaders != NULL)
  1357.     for (i = 0,ptr = (void *)response->ShortHeaders[i]; ptr != NULL; ptr = (void *)response->ShortHeaders[++i])
  1358.       freeWAISDocumentShortHeader((WAISDocumentShortHeader*)ptr);
  1359.   s_free(response->ShortHeaders);
  1360.    
  1361.   if (response->LongHeaders != NULL)
  1362.     for (i = 0,ptr = (void *)response->LongHeaders[i]; ptr != NULL; ptr = (void *)response->LongHeaders[++i])
  1363.       freeWAISDocumentLongHeader((WAISDocumentLongHeader*)ptr);
  1364.   s_free(response->LongHeaders);
  1365.    
  1366.   if (response->Text != NULL)
  1367.     for (i = 0,ptr = (void *)response->Text[i]; ptr != NULL; ptr = (void *)response->Text[++i])
  1368.       freeWAISDocumentText((WAISDocumentText*)ptr);
  1369.   s_free(response->Text);
  1370.    
  1371.   if (response->Headlines != NULL)
  1372.     for (i = 0,ptr = (void *)response->Headlines[i]; ptr != NULL; ptr = (void *)response->Headlines[++i])
  1373.       freeWAISDocumentHeadlines((WAISDocumentHeadlines*)ptr);
  1374.   s_free(response->Headlines);
  1375.    
  1376.   if (response->Codes != NULL)
  1377.     for (i = 0,ptr = (void *)response->Codes[i]; ptr != NULL; ptr = (void *)response->Codes[++i])
  1378.       freeWAISDocumentCodes((WAISDocumentCodes*)ptr);
  1379.   s_free(response->Codes);
  1380.    
  1381.   if (response->Diagnostics != NULL)
  1382.     for (i = 0,ptr = (void *)response->Diagnostics[i]; ptr != NULL; ptr = (void *)response->Diagnostics[++i])
  1383.       freeDiag((diagnosticRecord*)ptr);
  1384.   s_free(response->Diagnostics);
  1385.   
  1386.   s_free(response);
  1387. }
  1388.  
  1389. /*----------------------------------------------------------------------*/
  1390.  
  1391. char* 
  1392. writeSearchResponseInfo(query,buffer,len)
  1393. SearchResponseAPDU* query;
  1394. char* buffer;
  1395. long* len;
  1396. {
  1397.   unsigned long header_len = userInfoTagSize(DT_UserInformationLength,
  1398.                                              DefWAISSearchResponseSize);
  1399.   char* buf = buffer + header_len;
  1400.   WAISSearchResponse* info = (WAISSearchResponse*)query->DatabaseDiagnosticRecords;
  1401.   unsigned long size;
  1402.   void* header = NULL;
  1403.   long i;
  1404.   
  1405.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  1406.   
  1407.   buf = writeString(info->SeedWordsUsed,DT_SeedWordsUsed,buf,len);
  1408.   
  1409.   /* write out all the headers */
  1410.   if (info->DocHeaders != NULL)
  1411.     { for (i = 0,header = (void *)info->DocHeaders[i]; header != NULL; header = (void *)info->DocHeaders[++i])
  1412.         buf = writeWAISDocumentHeader((WAISDocumentHeader*)header,buf,len);
  1413.       }
  1414.    
  1415.   if (info->ShortHeaders != NULL)
  1416.     { for (i = 0,header = (void *)info->ShortHeaders[i]; header != NULL; header = (void *)info->ShortHeaders[++i])
  1417.         buf = writeWAISDocumentShortHeader((WAISDocumentShortHeader*)header,buf,len);
  1418.       }
  1419.  
  1420.   if (info->LongHeaders != NULL)
  1421.     { for (i = 0,header = (void *)info->LongHeaders[i]; header != NULL; header = (void *)info->LongHeaders[++i])
  1422.         buf = writeWAISDocumentLongHeader((WAISDocumentLongHeader*)header,buf,len);
  1423.       }
  1424.  
  1425.   if (info->Text != NULL)
  1426.     { for (i = 0,header = (void *)info->Text[i]; header != NULL; header = (void *)info->Text[++i])
  1427.         buf = writeWAISDocumentText((WAISDocumentText*)header,buf,len);
  1428.       }
  1429.  
  1430.   if (info->Headlines != NULL)
  1431.     { for (i = 0,header = (void *)info->Headlines[i]; header != NULL; header = (void *)info->Headlines[++i])
  1432.         buf = writeWAISDocumentHeadlines((WAISDocumentHeadlines*)header,buf,len);
  1433.       }
  1434.  
  1435.   if (info->Codes != NULL)
  1436.     { for (i = 0,header = (void *)info->Codes[i]; header != NULL;header = (void *)info->Codes[++i])
  1437.         buf = writeWAISDocumentCodes((WAISDocumentCodes*)header,buf,len);
  1438.       }
  1439.  
  1440.   if (info->Diagnostics != NULL)
  1441.     { for (i = 0, header = (void *)info->Diagnostics[i]; header != NULL; header = (void *)info->Diagnostics[++i])
  1442.         buf = writeDiag((diagnosticRecord*)header,buf,len);
  1443.       }
  1444.    
  1445.   /* now write the header and size */
  1446.   size = buf - buffer; 
  1447.   buf = writeUserInfoHeader(DT_UserInformationLength,size,header_len,buffer,len);
  1448.   
  1449.   return(buf);
  1450. }
  1451.  
  1452. /*----------------------------------------------------------------------*/
  1453.  
  1454. static void
  1455. cleanUpWaisSearchResponse _AP((char* buf,char* seedWordsUsed,
  1456.                                WAISDocumentHeader** docHeaders,
  1457.                                WAISDocumentShortHeader** shortHeaders,
  1458.                                WAISDocumentLongHeader** longHeaders,
  1459.                                WAISDocumentText** text,
  1460.                                WAISDocumentHeadlines** headlines,
  1461.                                WAISDocumentCodes** codes,
  1462.                                diagnosticRecord**diags));
  1463.  
  1464. static void
  1465. cleanUpWaisSearchResponse (buf,seedWordsUsed,docHeaders,shortHeaders,
  1466.                            longHeaders,text,headlines,codes,diags)
  1467. char* buf;
  1468. char* seedWordsUsed;
  1469. WAISDocumentHeader** docHeaders;
  1470. WAISDocumentShortHeader** shortHeaders;
  1471. WAISDocumentLongHeader** longHeaders;
  1472. WAISDocumentText** text;
  1473. WAISDocumentHeadlines** headlines;
  1474. WAISDocumentCodes** codes;
  1475. diagnosticRecord** diags;
  1476. /* if buf is NULL, we have just gotten a read error, and need to clean up 
  1477.    any state we have built.  If not, then everything is going fine, and
  1478.    we should just hang loose
  1479.  */
  1480. {
  1481.   void* ptr = NULL;
  1482.   long i;
  1483.  
  1484.   if (buf == NULL)                                              
  1485.    { s_free(seedWordsUsed);                             
  1486.      if (docHeaders != NULL)                            
  1487.        for (i = 0,ptr = (void *)docHeaders[i]; ptr != NULL; 
  1488.             ptr = (void *)docHeaders[++i])              
  1489.          freeWAISDocumentHeader((WAISDocumentHeader*)ptr);      
  1490.      s_free(docHeaders);                                
  1491.      if (shortHeaders != NULL)  
  1492.        for (i = 0,ptr = (void *)shortHeaders[i]; ptr != NULL;
  1493.             ptr = (void *)shortHeaders[++i])    
  1494.          freeWAISDocumentShortHeader((WAISDocumentShortHeader*)ptr);
  1495.      s_free(shortHeaders);                                              
  1496.      if (longHeaders != NULL)                           
  1497.        for (i = 0,ptr = (void *)longHeaders[i]; ptr != NULL; 
  1498.             ptr = (void *)longHeaders[++i])     
  1499.          freeWAISDocumentLongHeader((WAISDocumentLongHeader*)ptr);
  1500.      s_free(longHeaders);                               
  1501.      if (text != NULL)                                  
  1502.        for (i = 0,ptr = (void *)text[i]; ptr != NULL; ptr = (void *)text[++i])
  1503.          freeWAISDocumentText((WAISDocumentText*)ptr);  
  1504.      s_free(text);                                      
  1505.      if (headlines != NULL)                                     
  1506.        for (i = 0,ptr = (void *)headlines[i]; ptr != NULL;
  1507.             ptr = (void *)headlines[++i])               
  1508.          freeWAISDocumentHeadlines((WAISDocumentHeadlines*)ptr);        
  1509.      s_free(headlines);                                         
  1510.      if (codes != NULL)                              
  1511.        for (i = 0,ptr = (void *)codes[i]; ptr != NULL; 
  1512.             ptr = (void *)codes[++i])                           
  1513.          freeWAISDocumentCodes((WAISDocumentCodes*)ptr);         
  1514.      s_free(codes);                                     
  1515.      if (diags != NULL)                                 
  1516.        for (i = 0,ptr = (void *)diags[i]; ptr != NULL; 
  1517.             ptr = (void *)diags[++i])    
  1518.          freeDiag((diagnosticRecord*)ptr);           
  1519.      s_free(diags);
  1520.    }
  1521. }
  1522.  
  1523. /*----------------------------------------------------------------------*/
  1524.  
  1525. char*
  1526. readSearchResponseInfo(info,buffer)
  1527. void** info;
  1528. char* buffer;
  1529. {
  1530.   char* buf = buffer;
  1531.   unsigned long size; 
  1532.   unsigned long headerSize;
  1533.   data_tag tag;
  1534.   void* header = NULL;
  1535.   WAISDocumentHeader** docHeaders = NULL;
  1536.   WAISDocumentShortHeader** shortHeaders = NULL;
  1537.   WAISDocumentLongHeader** longHeaders = NULL;
  1538.   WAISDocumentText** text = NULL;
  1539.   WAISDocumentHeadlines** headlines = NULL;
  1540.   WAISDocumentCodes** codes = NULL;
  1541.   long numDocHeaders,numLongHeaders,numShortHeaders,numText,numHeadlines;
  1542.   long numCodes;
  1543.   char* seedWordsUsed = NULL;
  1544.   diagnosticRecord** diags = NULL;
  1545.   diagnosticRecord* diag = NULL;
  1546.   long numDiags = 0;
  1547.   
  1548.   numDocHeaders = numLongHeaders = numShortHeaders = numText = numHeadlines = numCodes = 0;
  1549.   
  1550.   buf = readUserInfoHeader(&tag,&size,buf);
  1551.   headerSize = buf - buffer;
  1552.     
  1553.   while (buf < (buffer + size + headerSize))
  1554.    { data_tag tag = peekTag(buf);
  1555.      switch (tag)
  1556.       { case DT_SeedWordsUsed:
  1557.           buf = readString(&seedWordsUsed,buf);
  1558.           break;
  1559.         case DT_DatabaseDiagnosticRecords:
  1560.           if (diags == NULL) /* create a new diag list */
  1561.            { diags = (diagnosticRecord**)s_malloc((size_t)sizeof(diagnosticRecord*) * 2);
  1562.            }
  1563.           else /* grow the diag list */
  1564.            { diags = (diagnosticRecord**)s_realloc((char*)diags,(size_t)(sizeof(diagnosticRecord*) * (numDiags + 2)));
  1565.            }
  1566.           buf = readDiag(&diag,buf);
  1567.           diags[numDiags++] = diag; /* put it in the list */
  1568.           diags[numDiags] = NULL;
  1569.           break;
  1570.         case DT_DocumentHeaderGroup:
  1571.                   if (docHeaders == NULL) /* create a new header list */
  1572.                    { docHeaders = (WAISDocumentHeader**)s_malloc((size_t)sizeof(WAISDocumentHeader*) * 2);
  1573.                    }
  1574.                   else /* grow the doc list */
  1575.                    { docHeaders = (WAISDocumentHeader**)s_realloc((char*)docHeaders,(size_t)(sizeof(WAISDocumentHeader*) * (numDocHeaders + 2)));
  1576.                    }
  1577.                   buf = readWAISDocumentHeader((WAISDocumentHeader**)&header,buf);
  1578.                   cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
  1579.                   RETURN_ON_NULL(buf);
  1580.                   docHeaders[numDocHeaders++] = 
  1581.                     (WAISDocumentHeader*)header; /* put it in the list */
  1582.                   docHeaders[numDocHeaders] = NULL;
  1583.                   break;
  1584.                 case DT_DocumentShortHeaderGroup:
  1585.                   if (shortHeaders == NULL) /* create a new header list */
  1586.                    { shortHeaders = (WAISDocumentShortHeader**)s_malloc((size_t)sizeof(WAISDocumentShortHeader*) * 2);
  1587.                    }
  1588.                   else /* grow the doc list */
  1589.                    { shortHeaders = (WAISDocumentShortHeader**)s_realloc((char*)shortHeaders,(size_t)(sizeof(WAISDocumentShortHeader*) * (numShortHeaders + 2)));
  1590.                    }
  1591.                   buf = readWAISDocumentShortHeader((WAISDocumentShortHeader**)&header,buf);
  1592.                   cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
  1593.                   RETURN_ON_NULL(buf);
  1594.                   shortHeaders[numShortHeaders++] = 
  1595.                     (WAISDocumentShortHeader*)header; /* put it in the list */
  1596.                   shortHeaders[numShortHeaders] = NULL;
  1597.                   break;
  1598.                 case DT_DocumentLongHeaderGroup:
  1599.                   if (longHeaders == NULL) /* create a new header list */
  1600.                    { longHeaders = (WAISDocumentLongHeader**)s_malloc((size_t)sizeof(WAISDocumentLongHeader*) * 2);
  1601.                    }
  1602.                   else /* grow the doc list */
  1603.                    { longHeaders = (WAISDocumentLongHeader**)s_realloc((char*)longHeaders,(size_t)(sizeof(WAISDocumentLongHeader*) * (numLongHeaders + 2)));
  1604.                    }
  1605.                   buf = readWAISDocumentLongHeader((WAISDocumentLongHeader**)&header,buf);
  1606.                   cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
  1607.                   RETURN_ON_NULL(buf);
  1608.                   longHeaders[numLongHeaders++] = 
  1609.                     (WAISDocumentLongHeader*)header; /* put it in the list */
  1610.                   longHeaders[numLongHeaders] = NULL;
  1611.                   break;
  1612.         case DT_DocumentTextGroup:
  1613.                   if (text == NULL) /* create a new list */
  1614.                    { text = (WAISDocumentText**)s_malloc((size_t)sizeof(WAISDocumentText*) * 2);
  1615.                    }
  1616.                   else /* grow the list */
  1617.                    { text = (WAISDocumentText**)s_realloc((char*)text,(size_t)(sizeof(WAISDocumentText*) * (numText + 2)));
  1618.                    }
  1619.                   buf = readWAISDocumentText((WAISDocumentText**)&header,buf);
  1620.                   cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
  1621.                   RETURN_ON_NULL(buf);
  1622.                   text[numText++] = 
  1623.                     (WAISDocumentText*)header; /* put it in the list */
  1624.                   text[numText] = NULL;
  1625.                   break;
  1626.                 case DT_DocumentHeadlineGroup:
  1627.                   if (headlines == NULL) /* create a new list */
  1628.                    { headlines = (WAISDocumentHeadlines**)s_malloc((size_t)sizeof(WAISDocumentHeadlines*) * 2);
  1629.                    }
  1630.                   else /* grow the list */
  1631.                    { headlines = (WAISDocumentHeadlines**)s_realloc((char*)headlines,(size_t)(sizeof(WAISDocumentHeadlines*) * (numHeadlines + 2)));
  1632.                    }
  1633.                   buf = readWAISDocumentHeadlines((WAISDocumentHeadlines**)&header,buf);
  1634.                   cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
  1635.                   RETURN_ON_NULL(buf);
  1636.                   headlines[numHeadlines++] = 
  1637.                     (WAISDocumentHeadlines*)header; /* put it in the list */
  1638.                   headlines[numHeadlines] = NULL;
  1639.                   break;
  1640.                 case DT_DocumentCodeGroup:
  1641.                   if (codes == NULL) /* create a new list */
  1642.                    { codes = (WAISDocumentCodes**)s_malloc((size_t)sizeof(WAISDocumentCodes*) * 2);
  1643.                    }
  1644.                   else /* grow the list */
  1645.                    { codes = (WAISDocumentCodes**)s_realloc((char*)codes,(size_t)(sizeof(WAISDocumentCodes*) * (numCodes + 2)));
  1646.                    }
  1647.                   buf = readWAISDocumentCodes((WAISDocumentCodes**)&header,buf);
  1648.                   cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
  1649.                   RETURN_ON_NULL(buf);
  1650.                   codes[numCodes++] = 
  1651.                     (WAISDocumentCodes*)header; /* put it in the list */
  1652.                   codes[numCodes] = NULL;
  1653.                   break;
  1654.         default:
  1655.           cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
  1656.           REPORT_READ_ERROR(buf);
  1657.           break;
  1658.       }
  1659.    }
  1660.           
  1661.   *info = (void *)makeWAISSearchResponse(seedWordsUsed,docHeaders,shortHeaders,
  1662.                                  longHeaders,text,headlines,codes,diags);
  1663.   
  1664.   return(buf);
  1665. }
  1666.  
  1667. /*----------------------------------------------------------------------*/
  1668.  
  1669. WAISDocumentText*
  1670. makeWAISDocumentText(docID,versionNumber,documentText)
  1671. any* docID;
  1672. long versionNumber;
  1673. any* documentText;
  1674. {
  1675.   WAISDocumentText* docText = (WAISDocumentText*)s_malloc((size_t)sizeof(WAISDocumentText));
  1676.  
  1677.   docText->DocumentID = docID;
  1678.   docText->VersionNumber = versionNumber;
  1679.   docText->DocumentText = documentText;
  1680.   
  1681.   return(docText);
  1682. }
  1683.  
  1684. /*----------------------------------------------------------------------*/
  1685.  
  1686. void 
  1687. freeWAISDocumentText(docText)
  1688. WAISDocumentText* docText;
  1689. {
  1690.   freeAny(docText->DocumentID);
  1691.   freeAny(docText->DocumentText);
  1692.   s_free(docText);
  1693. }
  1694.  
  1695. /*----------------------------------------------------------------------*/
  1696.  
  1697. char* 
  1698. writeWAISDocumentText(docText,buffer,len)
  1699. WAISDocumentText* docText;
  1700. char* buffer;
  1701. long* len;
  1702. {
  1703.   unsigned long header_len = userInfoTagSize(DT_DocumentTextGroup,
  1704.                                                                                         DefWAISDocTextSize);
  1705.   char* buf = buffer + header_len;
  1706.   unsigned long size;
  1707.   
  1708.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  1709.  
  1710.   buf = writeAny(docText->DocumentID,DT_DocumentID,buf,len);
  1711.   buf = writeNum(docText->VersionNumber,DT_VersionNumber,buf,len);
  1712.   buf = writeAny(docText->DocumentText,DT_DocumentText,buf,len);
  1713.   
  1714.   /* now write the header and size */
  1715.   size = buf - buffer; 
  1716.   buf = writeUserInfoHeader(DT_DocumentTextGroup,size,header_len,buffer,len);
  1717.  
  1718.   return(buf);
  1719. }
  1720.  
  1721. /*----------------------------------------------------------------------*/
  1722.  
  1723. char* 
  1724. readWAISDocumentText(docText,buffer)
  1725. WAISDocumentText** docText;
  1726. char* buffer;
  1727. {
  1728.   char* buf = buffer;
  1729.   unsigned long size; 
  1730.   unsigned long headerSize;
  1731.   data_tag tag;
  1732.   any *docID,*documentText;
  1733.   long versionNumber;
  1734.   
  1735.   docID = documentText = NULL;
  1736.   versionNumber = UNUSED;
  1737.   
  1738.   buf = readUserInfoHeader(&tag,&size,buf);
  1739.   headerSize = buf - buffer;
  1740.     
  1741.   while (buf < (buffer + size + headerSize))
  1742.    { data_tag tag = peekTag(buf);
  1743.      switch (tag)
  1744.       { case DT_DocumentID:
  1745.                   buf = readAny(&docID,buf);
  1746.                   break;
  1747.                 case DT_VersionNumber:
  1748.                   buf = readNum(&versionNumber,buf);
  1749.                   break;
  1750.                 case DT_DocumentText:
  1751.                   buf = readAny(&documentText,buf);
  1752.                   break;
  1753.         default:
  1754.           freeAny(docID);
  1755.           freeAny(documentText);
  1756.           REPORT_READ_ERROR(buf);
  1757.           break;
  1758.       }
  1759.    }
  1760.           
  1761.   *docText = makeWAISDocumentText(docID,versionNumber,documentText);
  1762.   return(buf);
  1763. }
  1764.  
  1765. /*----------------------------------------------------------------------*/
  1766.  
  1767. WAISDocumentHeadlines*
  1768. makeWAISDocumentHeadlines(docID,
  1769.                           versionNumber,
  1770.                           source,
  1771.                           date,
  1772.                           headline,
  1773.                           originCity)
  1774. any* docID;
  1775. long versionNumber;
  1776. char* source;
  1777. char* date;
  1778. char* headline;
  1779. char* originCity;
  1780. {
  1781.   WAISDocumentHeadlines* docHeadline =
  1782.     (WAISDocumentHeadlines*)s_malloc((size_t)sizeof(WAISDocumentHeadlines));
  1783.  
  1784.   docHeadline->DocumentID = docID;
  1785.   docHeadline->VersionNumber = versionNumber;
  1786.   docHeadline->Source = source;
  1787.   docHeadline->Date = date;
  1788.   docHeadline->Headline = headline;
  1789.   docHeadline->OriginCity = originCity;
  1790.   
  1791.   return(docHeadline);
  1792. }
  1793.  
  1794. /*----------------------------------------------------------------------*/
  1795.  
  1796. void 
  1797. freeWAISDocumentHeadlines(docHeadline)
  1798. WAISDocumentHeadlines* docHeadline;
  1799. {
  1800.   freeAny(docHeadline->DocumentID);
  1801.   s_free(docHeadline->Source);
  1802.   s_free(docHeadline->Date);
  1803.   s_free(docHeadline->Headline);
  1804.   s_free(docHeadline->OriginCity);
  1805.   s_free(docHeadline);
  1806. }
  1807.  
  1808. /*----------------------------------------------------------------------*/
  1809.  
  1810. char* 
  1811. writeWAISDocumentHeadlines(docHeadline,buffer,len)
  1812. WAISDocumentHeadlines* docHeadline;
  1813. char* buffer;
  1814. long* len;
  1815. {
  1816.   unsigned long header_len = userInfoTagSize(DT_DocumentHeadlineGroup,
  1817.                                                                                         DefWAISDocHeadlineSize);
  1818.   char* buf = buffer + header_len;
  1819.   unsigned long size;
  1820.   
  1821.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  1822.  
  1823.   buf = writeAny(docHeadline->DocumentID,DT_DocumentID,buf,len);
  1824.   buf = writeNum(docHeadline->VersionNumber,DT_VersionNumber,buf,len);
  1825.   buf = writeString(docHeadline->Source,DT_Source,buf,len);
  1826.   buf = writeString(docHeadline->Date,DT_Date,buf,len);
  1827.   buf = writeString(docHeadline->Headline,DT_Headline,buf,len);
  1828.   buf = writeString(docHeadline->OriginCity,DT_OriginCity,buf,len);
  1829.   
  1830.   /* now write the header and size */
  1831.   size = buf - buffer; 
  1832.   buf = writeUserInfoHeader(DT_DocumentHeadlineGroup,size,header_len,buffer,len);
  1833.  
  1834.   return(buf);
  1835. }
  1836.  
  1837. /*----------------------------------------------------------------------*/
  1838.  
  1839. char* 
  1840. readWAISDocumentHeadlines(docHeadline,buffer)
  1841. WAISDocumentHeadlines** docHeadline;
  1842. char* buffer;
  1843. {
  1844.   char* buf = buffer;
  1845.   unsigned long size; 
  1846.   unsigned long headerSize;
  1847.   data_tag tag;
  1848.   any* docID;
  1849.   long versionNumber;
  1850.   char *source,*date,*headline,*originCity;
  1851.   
  1852.   docID = NULL;
  1853.   versionNumber = UNUSED;
  1854.   source = date = headline = originCity = NULL;
  1855.   
  1856.   buf = readUserInfoHeader(&tag,&size,buf);
  1857.   headerSize = buf - buffer;
  1858.     
  1859.   while (buf < (buffer + size + headerSize))
  1860.    { data_tag tag = peekTag(buf);
  1861.      switch (tag)
  1862.       { case DT_DocumentID:
  1863.                   buf = readAny(&docID,buf);
  1864.                   break;
  1865.                 case DT_VersionNumber:
  1866.                   buf = readNum(&versionNumber,buf);
  1867.                   break;
  1868.                 case DT_Source:
  1869.                   buf = readString(&source,buf);
  1870.                   break;
  1871.                 case DT_Date:
  1872.                   buf = readString(&date,buf);
  1873.                   break;
  1874.                 case DT_Headline:
  1875.                   buf = readString(&headline,buf);
  1876.                   break;
  1877.                 case DT_OriginCity:
  1878.                   buf = readString(&originCity,buf);
  1879.                   break;
  1880.         default:
  1881.           freeAny(docID);
  1882.           s_free(source);
  1883.           s_free(date);
  1884.           s_free(headline);
  1885.           s_free(originCity);
  1886.           REPORT_READ_ERROR(buf);
  1887.           break;
  1888.       }
  1889.    }
  1890.           
  1891.   *docHeadline = makeWAISDocumentHeadlines(docID,versionNumber,source,date,
  1892.                                                                                headline,originCity);
  1893.   return(buf);
  1894. }
  1895.  
  1896. /*----------------------------------------------------------------------*/
  1897.  
  1898. WAISDocumentCodes*
  1899. makeWAISDocumentCodes(docID,
  1900.                       versionNumber,
  1901.                       stockCodes,
  1902.                       companyCodes,
  1903.                       industryCodes)
  1904. any* docID;
  1905. long versionNumber;
  1906. char* stockCodes;
  1907. char* companyCodes;
  1908. char* industryCodes;
  1909. {
  1910.   WAISDocumentCodes* docCodes = (WAISDocumentCodes*)s_malloc((size_t)sizeof(WAISDocumentCodes));
  1911.  
  1912.   docCodes->DocumentID = docID;
  1913.   docCodes->VersionNumber = versionNumber;
  1914.   docCodes->StockCodes = stockCodes;
  1915.   docCodes->CompanyCodes = companyCodes;
  1916.   docCodes->IndustryCodes = industryCodes;
  1917.   
  1918.   return(docCodes);
  1919. }
  1920.  
  1921. /*----------------------------------------------------------------------*/
  1922.  
  1923. void 
  1924. freeWAISDocumentCodes(docCodes)
  1925. WAISDocumentCodes* docCodes;
  1926. {
  1927.   freeAny(docCodes->DocumentID);
  1928.   s_free(docCodes->StockCodes);
  1929.   s_free(docCodes->CompanyCodes);
  1930.   s_free(docCodes->IndustryCodes);
  1931.   s_free(docCodes);
  1932. }
  1933.  
  1934. /*----------------------------------------------------------------------*/
  1935.  
  1936. char* 
  1937. writeWAISDocumentCodes(docCodes,buffer,len)
  1938. WAISDocumentCodes* docCodes;
  1939. char* buffer;
  1940. long* len;
  1941. {
  1942.   unsigned long header_len = userInfoTagSize(DT_DocumentCodeGroup ,
  1943.                                                                                         DefWAISDocCodeSize);
  1944.   char* buf = buffer + header_len;
  1945.   unsigned long size;
  1946.   
  1947.   RESERVE_SPACE_FOR_WAIS_HEADER(len);
  1948.  
  1949.   buf = writeAny(docCodes->DocumentID,DT_DocumentID,buf,len);
  1950.   buf = writeNum(docCodes->VersionNumber,DT_VersionNumber,buf,len);
  1951.   buf = writeString(docCodes->StockCodes,DT_StockCodes,buf,len);
  1952.   buf = writeString(docCodes->CompanyCodes,DT_CompanyCodes,buf,len);
  1953.   buf = writeString(docCodes->IndustryCodes,DT_IndustryCodes,buf,len);
  1954.   
  1955.   /* now write the header and size */
  1956.   size = buf - buffer; 
  1957.   buf = writeUserInfoHeader(DT_DocumentCodeGroup,size,header_len,buffer,len);
  1958.  
  1959.   return(buf);
  1960. }
  1961.  
  1962. /*----------------------------------------------------------------------*/
  1963.  
  1964. char* 
  1965. readWAISDocumentCodes(docCodes,buffer)
  1966. WAISDocumentCodes** docCodes;
  1967. char* buffer;
  1968. {
  1969.   char* buf = buffer;
  1970.   unsigned long size; 
  1971.   unsigned long headerSize;
  1972.   data_tag tag;
  1973.   any* docID;
  1974.   long versionNumber;
  1975.   char *stockCodes,*companyCodes,*industryCodes;
  1976.   
  1977.   docID = NULL;
  1978.   versionNumber = UNUSED;
  1979.   stockCodes = companyCodes = industryCodes = NULL;
  1980.   
  1981.   buf = readUserInfoHeader(&tag,&size,buf);
  1982.   headerSize = buf - buffer;
  1983.     
  1984.   while (buf < (buffer + size + headerSize))
  1985.    { data_tag tag = peekTag(buf);
  1986.      switch (tag)
  1987.       { case DT_DocumentID:
  1988.                   buf = readAny(&docID,buf);
  1989.                   break;
  1990.                 case DT_VersionNumber:
  1991.                   buf = readNum(&versionNumber,buf);
  1992.                   break;
  1993.                 case DT_StockCodes:
  1994.                   buf = readString(&stockCodes,buf);
  1995.                   break;
  1996.                 case DT_CompanyCodes:
  1997.                   buf = readString(&companyCodes,buf);
  1998.                   break;
  1999.                 case DT_IndustryCodes:
  2000.                   buf = readString(&industryCodes,buf);
  2001.                   break;
  2002.         default:
  2003.           freeAny(docID);
  2004.           s_free(stockCodes);
  2005.           s_free(companyCodes);
  2006.           s_free(industryCodes);
  2007.           REPORT_READ_ERROR(buf);
  2008.           break;
  2009.       }
  2010.    }
  2011.           
  2012.   *docCodes = makeWAISDocumentCodes(docID,versionNumber,stockCodes,
  2013.                                                                         companyCodes,industryCodes);
  2014.   return(buf);
  2015. }
  2016.  
  2017. /*----------------------------------------------------------------------*/
  2018.  
  2019. char* 
  2020. writePresentInfo(present,buffer,len)
  2021. PresentAPDU* present;
  2022. char* buffer;
  2023. long* len;
  2024. {
  2025.   /* The WAIS protocol doesn't use present info */
  2026.   return(buffer);
  2027. }
  2028.  
  2029. /*----------------------------------------------------------------------*/
  2030.  
  2031. char* 
  2032. readPresentInfo(info,buffer)
  2033. void** info;
  2034. char* buffer;
  2035. {
  2036.   /* The WAIS protocol doesn't use present info */
  2037.   *info = NULL;
  2038.   return(buffer);
  2039. }
  2040.  
  2041. /*----------------------------------------------------------------------*/
  2042.  
  2043. char* 
  2044. writePresentResponseInfo(response,buffer,len)
  2045. PresentResponseAPDU* response;
  2046. char* buffer;
  2047. long* len;
  2048. {
  2049.   /* The WAIS protocol doesn't use presentResponse info */
  2050.   return(buffer);
  2051. }
  2052.  
  2053. /*----------------------------------------------------------------------*/
  2054.  
  2055. char* 
  2056. readPresentResponseInfo(info,buffer)
  2057. void** info;
  2058. char* buffer;
  2059. {
  2060.   /* The WAIS protocol doesn't use presentResponse info */
  2061.   *info = NULL;
  2062.   return(buffer);
  2063. }
  2064.  
  2065. /*----------------------------------------------------------------------*/
  2066.  
  2067. /* support for type 1 queries */
  2068.  
  2069. /* new use values (for the chunk types) */
  2070. #define BYTE            "wb"
  2071. #define LINE            "wl"
  2072. #define PARAGRAPH       "wp"
  2073. #define DATA_TYPE       "wt"
  2074.  
  2075. /* WAIS supports the following semantics for type 1 queries:
  2076.        
  2077.      1.  retrieve the header/codes from a document:
  2078.  
  2079.             System_Control_Number = docID
  2080.             Data Type = type (optional)
  2081.             And
  2082.  
  2083.      2.  retrieve a fragment of the text of a document:
  2084.  
  2085.             System_Control_Number = docID
  2086.             Data Type = type (optional)
  2087.             And
  2088.                 Chunk >= start
  2089.                 And
  2090.                 Chunk < end
  2091.                 And
  2092.  
  2093.                 Information from multiple documents may be requested by using 
  2094.                 groups of the above joined by:
  2095.  
  2096.             OR
  2097.  
  2098.                 ( XXX does an OR come after every group but the first, or do they
  2099.               all come at the end? )
  2100.               
  2101.         ( XXX return type could be in the element set)
  2102. */
  2103.  
  2104. static query_term** makeWAISQueryTerms _AP((DocObj** docs));
  2105.    
  2106. static query_term**
  2107. makeWAISQueryTerms(docs)
  2108. DocObj** docs;
  2109. /* given a null terminated list of docObjs, construct the appropriate
  2110.    query of the form given above
  2111.  */
  2112. {
  2113.   query_term** terms = NULL;
  2114.   long numTerms = 0;
  2115.   DocObj* doc = NULL;
  2116.   long i;
  2117.  
  2118.   if (docs == NULL)
  2119.     return((query_term**)NULL);
  2120.  
  2121.   terms = (query_term**)s_malloc((size_t)(sizeof(query_term*) * 1));
  2122.   terms[numTerms] = NULL;
  2123.  
  2124.   /* loop through the docs making terms for them all */
  2125.   for (i = 0,doc = docs[i]; doc != NULL; doc = docs[++i])
  2126.     { any* type = NULL;
  2127.  
  2128.       if (doc->Type != NULL)
  2129.         type = stringToAny(doc->Type);
  2130.  
  2131.       if (doc->ChunkCode == CT_document) /* a whole document */
  2132.         { terms = (query_term**)s_realloc((char*)terms,
  2133.                                           (size_t)(sizeof(query_term*) * 
  2134.                                                    (numTerms + 3 + 1)));
  2135.           terms[numTerms++] = makeAttributeTerm(SYSTEM_CONTROL_NUMBER,
  2136.                                                 EQUAL,IGNORE,IGNORE,
  2137.                                                 IGNORE,IGNORE,doc->DocumentID);
  2138.           if (type != NULL)
  2139.            { terms[numTerms++] = makeAttributeTerm(DATA_TYPE,EQUAL,
  2140.                                                    IGNORE,IGNORE,IGNORE,
  2141.                                                    IGNORE,type);
  2142.              terms[numTerms++] = makeOperatorTerm(AND);
  2143.            }
  2144.           terms[numTerms] = NULL;
  2145.         }
  2146.       else                      /* a document fragment */
  2147.         {       char chunk_att[ATTRIBUTE_SIZE];
  2148.                 any* startChunk = NULL;
  2149.                 any* endChunk = NULL;
  2150.  
  2151.                 terms = (query_term**)s_realloc((char*)terms,
  2152.                                                 (size_t)(sizeof(query_term*) * 
  2153.                                                          (numTerms + 7 + 1)));
  2154.  
  2155.                 switch (doc->ChunkCode)
  2156.                   { case CT_byte:
  2157.                     case CT_line:
  2158.                       { char start[20],end[20];
  2159.                         (doc->ChunkCode == CT_byte) ?
  2160.                           strncpy(chunk_att,BYTE,ATTRIBUTE_SIZE) :
  2161.                         strncpy(chunk_att,LINE,ATTRIBUTE_SIZE); 
  2162.                         sprintf(start,"%ld",doc->ChunkStart.Pos);
  2163.                         startChunk = stringToAny(start);
  2164.                         sprintf(end,"%ld",doc->ChunkEnd.Pos);
  2165.                         endChunk = stringToAny(end);
  2166.                       }
  2167.                       break;
  2168.                     case CT_paragraph:
  2169.                       strncpy(chunk_att,PARAGRAPH,ATTRIBUTE_SIZE);
  2170.                       startChunk = doc->ChunkStart.ID;
  2171.                       endChunk = doc->ChunkEnd.ID;
  2172.                       break;
  2173.                     default:
  2174.                       /* error */
  2175.                       break;
  2176.                     }
  2177.  
  2178.                 terms[numTerms++] = makeAttributeTerm(SYSTEM_CONTROL_NUMBER,
  2179.                                                       EQUAL,IGNORE,IGNORE,
  2180.                                                       IGNORE,
  2181.                                                       IGNORE,doc->DocumentID);
  2182.                 if (type != NULL)
  2183.                  { terms[numTerms++] = makeAttributeTerm(DATA_TYPE,EQUAL,IGNORE,
  2184.                                                          IGNORE,IGNORE,IGNORE,
  2185.                                                          type);
  2186.                    terms[numTerms++] = makeOperatorTerm(AND);
  2187.                  }
  2188.                 terms[numTerms++] = makeAttributeTerm(chunk_att,
  2189.                                                       GREATER_THAN_OR_EQUAL,
  2190.                                                       IGNORE,IGNORE,IGNORE, 
  2191.                                                       IGNORE,
  2192.                                                       startChunk);
  2193.                 terms[numTerms++] = makeOperatorTerm(AND);
  2194.                 terms[numTerms++] = makeAttributeTerm(chunk_att,LESS_THAN,
  2195.                                                       IGNORE,IGNORE,IGNORE,
  2196.                                                       IGNORE,
  2197.                                                       endChunk);
  2198.                 terms[numTerms++] = makeOperatorTerm(AND);
  2199.                 terms[numTerms] = NULL;
  2200.  
  2201.                 if (doc->ChunkCode == CT_byte || doc->ChunkCode == CT_line)
  2202.                   { freeAny(startChunk);
  2203.                     freeAny(endChunk);
  2204.                   }
  2205.               }
  2206.       
  2207.       freeAny(type);
  2208.       
  2209.      if (i != 0) /* multiple independent queries, need a disjunction */
  2210.         { terms = (query_term**)s_realloc((char*)terms,
  2211.                                           (size_t)(sizeof(query_term*) * 
  2212.                                                    (numTerms + 1 + 1)));
  2213.           terms[numTerms++] = makeOperatorTerm(OR);
  2214.           terms[numTerms] = NULL;
  2215.         }
  2216.     }
  2217.  
  2218.   return(terms);
  2219. }
  2220.  
  2221. /*----------------------------------------------------------------------*/
  2222.  
  2223. static DocObj** makeWAISQueryDocs _AP((query_term** terms));
  2224.  
  2225. static DocObj** 
  2226. makeWAISQueryDocs(terms)
  2227. query_term** terms;
  2228. /* given a list of terms in the form given above, convert them to 
  2229.    DocObjs.
  2230.  */
  2231. {
  2232.   query_term* docTerm = NULL;
  2233.   query_term* fragmentTerm = NULL;
  2234.   DocObj** docs = NULL;
  2235.   DocObj* doc = NULL;
  2236.   long docNum,termNum;
  2237.  
  2238.   docNum = termNum = 0;
  2239.   
  2240.   docs = (DocObj**)s_malloc((size_t)(sizeof(DocObj*) * 1));
  2241.   docs[docNum] = NULL;
  2242.  
  2243.   /* translate the terms into DocObjs */
  2244.   while (true)
  2245.     {         
  2246.       query_term* typeTerm = NULL;
  2247.       char* type = NULL;
  2248.       long startTermOffset;
  2249.  
  2250.       docTerm = terms[termNum];
  2251.      
  2252.       if (docTerm == NULL)
  2253.         break;                  /* we're done converting */;
  2254.  
  2255.       typeTerm = terms[termNum + 1]; /* get the lead Term if it exists */
  2256.  
  2257.       if (strcmp(typeTerm->Use,DATA_TYPE) == 0) /* we do have a type */
  2258.        { startTermOffset = 3;   
  2259.          type = anyToString(typeTerm->Term);
  2260.        }
  2261.       else                                      /* no type */
  2262.        { startTermOffset = 1;
  2263.          typeTerm = NULL;
  2264.          type = NULL;
  2265.        }
  2266.  
  2267.       /* grow the doc list */
  2268.       docs = (DocObj**)s_realloc((char*)docs,(size_t)(sizeof(DocObj*) * 
  2269.                                                       (docNum + 1 + 1)));
  2270.  
  2271.       /* figure out what kind of docObj to build - and build it */
  2272.       fragmentTerm = terms[termNum + startTermOffset];
  2273.       if (fragmentTerm != NULL && fragmentTerm->TermType == TT_Attribute)
  2274.         {                       /* build a document fragment */
  2275.           query_term* startTerm = fragmentTerm;
  2276.           query_term* endTerm = terms[termNum + startTermOffset + 2]; 
  2277.  
  2278.           if (strcmp(startTerm->Use,BYTE) == 0) /* a byte chunk */
  2279.             doc = makeDocObjUsingBytes(duplicateAny(docTerm->Term),
  2280.                                        type,
  2281.                                        anyToLong(startTerm->Term),
  2282.                                        anyToLong(endTerm->Term));
  2283.           else if (strcmp(startTerm->Use,LINE) == 0) /* a line chunk */
  2284.             doc = makeDocObjUsingLines(duplicateAny(docTerm->Term),
  2285.                                        type,
  2286.                                        anyToLong(startTerm->Term),
  2287.                                        anyToLong(endTerm->Term));
  2288.           else                  /* a paragraph chunk */
  2289.             doc = makeDocObjUsingParagraphs(duplicateAny(docTerm->Term),
  2290.                                             type,
  2291.                                             duplicateAny(startTerm->Term),
  2292.                                             duplicateAny(endTerm->Term));
  2293.           termNum += (startTermOffset + 4);     /* point to next term */
  2294.         }
  2295.       else                      /* build a full document */
  2296.         { 
  2297.           doc = makeDocObjUsingWholeDocument(duplicateAny(docTerm->Term),
  2298.                                              type);
  2299.           termNum += startTermOffset;   /* point to next term */
  2300.         }
  2301.      
  2302.       docs[docNum++] = doc;     /* insert the new document */
  2303.          
  2304.       docs[docNum] = NULL;      /* keep the doc list terminated */
  2305.  
  2306.          
  2307.       if (terms[termNum] != NULL)
  2308.         termNum++; /* skip the OR operator it necessary */
  2309.       else
  2310.         break; /* we are done */
  2311.     }
  2312.  
  2313.   return(docs);
  2314. }
  2315.  
  2316. /*----------------------------------------------------------------------*/
  2317.  
  2318. any* 
  2319. makeWAISTextQuery(docs)
  2320. DocObj** docs;
  2321. /* given a list of DocObjs, return an any whose contents is the corresponding
  2322.    type 1 query
  2323.  */
  2324. {
  2325.   any *buf = NULL;
  2326.   query_term** terms = NULL;
  2327.   
  2328.   terms = makeWAISQueryTerms(docs);
  2329.   buf = writeQuery(terms);
  2330.   
  2331.   doList((void**)terms,freeTerm);
  2332.   s_free(terms);
  2333.   
  2334.   return(buf);
  2335. }
  2336.  
  2337. /*----------------------------------------------------------------------*/
  2338.  
  2339. DocObj** 
  2340. readWAISTextQuery(buf)
  2341. any* buf;
  2342. /* given an any whose contents are type 1 queries of the WAIS sort, 
  2343.    construct a list of the corresponding DocObjs
  2344.  */
  2345. {
  2346.   query_term** terms = NULL;
  2347.   DocObj** docs = NULL;
  2348.   
  2349.   terms = readQuery(buf);
  2350.   docs = makeWAISQueryDocs(terms);
  2351.   
  2352.   doList((void**)terms,freeTerm);
  2353.   s_free(terms);
  2354.   
  2355.   return(docs);
  2356. }
  2357.  
  2358. /*----------------------------------------------------------------------*/
  2359. /* Customized free WAIS object routines:                                */
  2360. /*                                                                      */
  2361. /*   This set of procedures is for applications to free a WAIS object   */
  2362. /*   which was made with makeWAISFOO.                                   */
  2363. /*   Each procedure frees only the memory that was allocated in its     */
  2364. /*   associated makeWAISFOO routine, thus it's not necessary for the    */
  2365. /*   caller to assign nulls to the pointer fields of the WAIS object.  */
  2366. /*----------------------------------------------------------------------*/
  2367.  
  2368. void 
  2369. CSTFreeWAISInitResponse(init)
  2370. WAISInitResponse* init;
  2371. /* free an object made with makeWAISInitResponse */
  2372. {
  2373.   s_free(init);
  2374. }
  2375.  
  2376. /*----------------------------------------------------------------------*/
  2377.  
  2378. void 
  2379. CSTFreeWAISSearch(query)
  2380. WAISSearch* query;
  2381. /* destroy an object made with makeWAISSearch() */
  2382. { 
  2383.   s_free(query);
  2384. }
  2385.  
  2386. /*----------------------------------------------------------------------*/
  2387.  
  2388. void
  2389. CSTFreeDocObj(doc)
  2390. DocObj* doc;
  2391. /* free a docObj */
  2392. { 
  2393.     s_free(doc);
  2394. }
  2395.  
  2396. /*----------------------------------------------------------------------*/
  2397.  
  2398. void
  2399. CSTFreeWAISDocumentHeader(header)
  2400. WAISDocumentHeader* header;
  2401. { 
  2402.     s_free(header);
  2403. }
  2404.  
  2405. /*----------------------------------------------------------------------*/
  2406.  
  2407. void
  2408. CSTFreeWAISDocumentShortHeader(header)
  2409. WAISDocumentShortHeader* header;
  2410. { 
  2411.   s_free(header);
  2412. }
  2413. /*----------------------------------------------------------------------*/
  2414.  
  2415. void
  2416. CSTFreeWAISDocumentLongHeader(header)
  2417. WAISDocumentLongHeader* header;
  2418. {
  2419.   s_free(header);
  2420. }
  2421.  
  2422. /*----------------------------------------------------------------------*/
  2423.  
  2424. void
  2425. CSTFreeWAISSearchResponse(response)
  2426. WAISSearchResponse* response;
  2427. { 
  2428.   s_free(response);
  2429. }
  2430.  
  2431. /*----------------------------------------------------------------------*/
  2432.  
  2433. void 
  2434. CSTFreeWAISDocumentText(docText)
  2435. WAISDocumentText* docText;
  2436. { 
  2437.   s_free(docText);
  2438. }
  2439.  
  2440. /*----------------------------------------------------------------------*/
  2441.  
  2442. void 
  2443. CSTFreeWAISDocumentHeadlines(docHeadline)
  2444. WAISDocumentHeadlines* docHeadline;
  2445. { 
  2446.   s_free(docHeadline);
  2447. }
  2448.  
  2449. /*----------------------------------------------------------------------*/
  2450.  
  2451. void 
  2452. CSTFreeWAISDocumentCodes(docCodes)
  2453. WAISDocumentCodes* docCodes;
  2454. {
  2455.   s_free(docCodes);
  2456. }
  2457.  
  2458. /*----------------------------------------------------------------------*/
  2459.  
  2460. void 
  2461. CSTFreeWAISTextQuery(query)
  2462. any* query;
  2463. {
  2464.    freeAny(query);
  2465. }
  2466.  
  2467. /*----------------------------------------------------------------------*/
  2468.